class Promise {
  // 将现有对象转为 Promise 对象
  static resolve(value) {
    // 如果参数是 Promise 实例，那么Promise.resolve将不做任何修改、原封不动地返回这个实例。
    if (value instanceof Promise) return value;
    // 参数是一个thenable对象（具有then方法的对象）,Promise.resolve方法会将这个对象转为 Promise 对象，然后就立即执行thenable对象的then方法。
    if (typeof value === 'object' || typeof value === 'function') {
      try {
        let then = value.then;
        if (typeof then === 'function') {
          return new Promise(then.bind(value));
        }
      } catch (e) {
        return new Promise((resolve, reject) => {
          reject(e);
        })
      }
    }
    // 参数不是具有then方法的对象，或根本就不是对象,Promise.resolve方法返回一个新的 Promise 对象，状态为resolved。
    return new Promise((resolve, reject) => {
      resolve(value);
    })
  }
  // 返回一个新的 Promise 实例，该实例的状态为rejected。
  static reject(reason) {
    return new Promise((resolve, reject) => {
      reject(reason);
    })
  }
  // 用于将多个 Promise 实例，包装成一个新的 Promise 实例。只有所有状态都变为fulfilled，p的状态才会是fulfilled
  static all(promises) {
    const values = [];
    let resolvedCount = 0;
    return new Promise((resolve, reject) => {
      promises.forEach((p, index) => {
        Promise.resolve(p).then(value => {
          resolvedCount++;
          values[index] = value;
          if (resolvedCount === promises.length) {
            resolve(values);
          }
        }, reason => {
          reject(reason);
        })
      })
    })
  }
  // 只要有一个实例率先改变状态，状态就跟着改变。那个率先改变的 Promise 实例的返回值，就传递给回调函数。
  static race(promises) {
    return new Promise((resolve, reject) => {
      promises.forEach((p, index) => {
        Promise.resolve(p).then(value => {
          resolve(value);
        }, reason => {
          reject(reason);
        })
      })
    })
  }
  catch(onRejected) {
    return this.then(undefined, onRejected);
  }
  finally(callback) {
    return this.then(
      value => Promise.resolve(callback()).then(() => value),
      reason => Promise.resolve(callback()).then(() => { throw reason })
    )
  }
}